home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / Cpp4VB / WINTLB / SHELL.ODL < prev    next >
Text File  |  1996-04-17  |  19KB  |  516 lines
  1.  
  2. [
  3. uuid(54674052-3A82-101B-8181-00AA003743D3),
  4. helpstring("Shell"),
  5. #if WIN32
  6. dllname("SHELL32.DLL")
  7. #else
  8. dllname("SHELL.DLL")
  9. #endif
  10. ]
  11. module Shell {
  12.  
  13.     // Shell functions, types, and definitions
  14.     /*
  15.     UINT WINAPI DragQueryFileA(HDROP,UINT,LPSTR,UINT);
  16.  
  17.     BOOL WINAPI DragQueryPoint(HDROP,LPPOINT);
  18.  
  19.     VOID WINAPI DragFinish(HDROP);
  20.  
  21.     VOID WINAPI DragAcceptFiles(HWND,BOOL);
  22.     */
  23.  
  24.     /*
  25.     typedef struct _DRAGINFOA {
  26.         UINT uSize;                 // Init with sizeof(DRAGINFO)
  27.         POINT pt;
  28.         BOOL fNC;
  29.         LPSTR   lpFileList;
  30.         DWORD grfKeyState;
  31.     } DRAGINFOA, FAR* LPDRAGINFOA;
  32.     typedef DRAGINFOA DRAGINFO;
  33.     typedef LPDRAGINFOA LPDRAGINFO;
  34.     */
  35.  
  36.     [
  37.     #ifdef WIN32
  38.     usesgetlasterror,
  39.     entry("ShellExecuteA"),
  40.     #else
  41.     entry("ShellExecute"),
  42.     #endif
  43.     helpstring("Opens or prints specified executable or document file"),
  44.     ]
  45.     HINSTANCE WINAPI ShellExecute([in] HWND hwnd,
  46.                                   [in] LPCSTR lpOperation,
  47.                                   [in] LPCSTR lpFile,
  48.                                   [in] LPCSTR lpParameters,
  49.                                   [in] LPCSTR lpDirectory,
  50.                                   [in] INT nShowCmd);
  51.     [
  52.     #ifdef WIN32
  53.     usesgetlasterror,
  54.     entry("FindExecutableA"),
  55.     #else
  56.     entry("FindExecutable"),
  57.     #endif
  58.     helpstring("Retrieves name and handle of executable file associated with the specified filename"),
  59.     ]
  60.     HINSTANCE WINAPI FindExecutable([in] LPCSTR lpFile,
  61.                                     [in] LPCSTR lpDirectory,
  62.                                     [in, out] LPSTR lpResult);
  63.  
  64.     // LPWSTR * WINAPI CommandLineToArgvW(LPCWSTR lpCmdLine, int*pNumArgs);
  65.  
  66.     [
  67.     #ifdef WIN32
  68.     usesgetlasterror,
  69.     entry("ShellAboutA"),
  70.     #else
  71.     entry("ShellAbout"),
  72.     #endif
  73.     helpstring("Displays an About Box"),
  74.     ]
  75.     INT WINAPI ShellAbout([in] HWND hWnd, [in] LPCSTR szApp,
  76.                           [in] LPCSTR szOtherStuff,
  77.                           [in] HICON hIcon);
  78.  
  79.     // HICON      WINAPI DuplicateIcon(HINSTANCE hInst, HICON hIcon);
  80.  
  81.     [
  82.     #ifdef WIN32
  83.     usesgetlasterror,
  84.     entry("ExtractAssociatedIconA"),
  85.     #else
  86.     entry("ExtractAssociatedIcon"),
  87.     #endif
  88.     helpstring("Returns handle of indexed icon found in a file or in an associated executable file"),
  89.     ]
  90.     HICON     WINAPI ExtractAssociatedIcon([in] HINSTANCE hInst,
  91.                                            [in] LPSTR lpIconPath,
  92.                                            [in,out] WORD FAR * lpiIcon);
  93.  
  94.     [
  95.     #ifdef WIN32
  96.     usesgetlasterror,
  97.     entry("ExtractIconA"),
  98.     #else
  99.     entry("ExtractIcon"),
  100.     #endif
  101.     helpstring("Retrieves handle of an icon from given executable file, DLL, or icon file"),
  102.     ]
  103.     HICON     WINAPI ExtractIcon([in] HINSTANCE hInst,
  104.                                  [in] LPCSTR lpszExeFileName,
  105.                                  [in] UINT nIconIndex);
  106.  
  107.  
  108.     // AppBar stuff
  109.     /*
  110.     const DWORD ABM_NEW             = 0x00000000;
  111.     const DWORD ABM_REMOVE          = 0x00000001;
  112.     const DWORD ABM_QUERYPOS        = 0x00000002;
  113.     const DWORD ABM_SETPOS          = 0x00000003;
  114.     const DWORD ABM_GETSTATE        = 0x00000004;
  115.     const DWORD ABM_GETTASKBARPOS   = 0x00000005;
  116.     const DWORD ABM_ACTIVATE        = 0x00000006;  // lParam == TRUE/FALSE means activate/deactivate
  117.     const DWORD ABM_GETAUTOHIDEBAR  = 0x00000007;
  118.     const DWORD ABM_SETAUTOHIDEBAR  = 0x00000008;  // This can fail at any time.
  119.                                                    // MUST check the result
  120.                                                    // lParam = TRUE/FALSE  Set/Unset
  121.                                                    // uEdge = what edge
  122.     const DWORD ABM_WINDOWPOSCHANGED = 0x0000009;
  123.  
  124.  
  125.     // these are put in the wparam of callback messages
  126.     const DWORD ABN_STATECHANGE    = 0x0000000;
  127.     const DWORD ABN_POSCHANGED     = 0x0000001;
  128.     const DWORD ABN_FULLSCREENAPP  = 0x0000002;
  129.     const DWORD ABN_WINDOWARRANGE  = 0x0000003; // lParam == TRUE means hide
  130.  
  131.     // flags for get state
  132.     const DWORD ABS_AUTOHIDE       = 0x0000001;
  133.     const DWORD ABS_ALWAYSONTO     = 0x0000002;
  134.  
  135.     const int ABE_LEFT    = 0;
  136.     const int ABE_TOP     = 1;
  137.     const int ABE_RIGHT   = 2;
  138.     const int ABE_BOTTOM  = 3;
  139.     */
  140.  
  141.     /*
  142.     typedef struct _AppBarData
  143.     {
  144.         DWORD cbSize;
  145.         HWND hWnd;
  146.         UINT uCallbackMessage;
  147.         UINT uEdge;
  148.         RECT rc;
  149.         LPARAM lParam; // message specific
  150.     } APPBARDATA, *PAPPBARDATA;
  151.     */
  152.  
  153.     // UINT WINAPI SHAppBarMessage(DWORD dwMessage, PAPPBARDATA pData);
  154.  
  155.     //  EndAppBar
  156.  
  157.     // DWORD WINAPI DoEnvironmentSubstA(LPSTR szString, UINT cbString);
  158.  
  159.     // LPSTR WINAPI FindEnvironmentStringA(LPSTR szEnvVar);
  160.  
  161.     //        #define EIRESID(x) (-1 * (int)(x))
  162.  
  163.     /*
  164.     UINT WINAPI ExtractIconExA(LPCSTR lpszFile, int nIconIndex,
  165.                                HICON FAR *phiconLarge,
  166.                                HICON FAR *phiconSmall, UINT nIcons);
  167.     */
  168.  
  169.     #ifdef WIN32
  170.     //
  171.     // SHAddToRecentDocs
  172.     //
  173.     [ helpstring("SHAddToRecentDocs: Add item identifier list") ]
  174.     const long SHARD_PIDL   = 0x00000001;
  175.     [ helpstring("SHAddToRecentDocs: Add path string") ]
  176.     const long SHARD_PATH   = 0x00000002;
  177.  
  178.     [
  179.     usesgetlasterror,
  180.     entry("SHAddToRecentDocs"),
  181.     helpstring("Adds a file to shell list of recently used documents, or clears documents from the list"),
  182.     ]
  183.     void WINAPI SHAddToRecentDocs([in] UINT uFlags, [in] LPSTR pv);
  184.  
  185.     [
  186.     usesgetlasterror,
  187.     entry("SHAddToRecentDocs"),
  188.     helpstring("Adds an item ID list to shell list of recently used documents, or clears documents from the list"),
  189.     ]
  190.     void WINAPI SHAddToRecentDocsItem([in] UINT uFlags, [in] DWORD pv);
  191.  
  192.  
  193.     //----------
  194.     //
  195.     // SHGetPathFromIDList
  196.     //
  197.     //  This function assumes the size of the buffer (MAX_PATH). The pidl
  198.     // should point to a file system object.
  199.     //
  200.     //----------
  201.  
  202.     [
  203.     usesgetlasterror,
  204.     entry("SHGetPathFromIDList"),
  205.     helpstring("Converts an item ID list pointer to a file system path (cMaxPath buffer expected)"),
  206.     ]
  207.     BOOL WINAPI SHGetPathFromIDList([in] DWORD pidl, [in] LPSTR pszPath);
  208.  
  209.     //// Shell File Operations
  210.  
  211.     //         #ifndef FO_MOVE //these need to be kept in sync with the ones in shlobj.h
  212.     /*
  213.     const WORD FO_MOVE         = 0x0001;
  214.     const WORD FO_COPY         = 0x0002;
  215.     const WORD FO_DELETE       = 0x0003;
  216.     const WORD FO_RENAME       = 0x0004;
  217.  
  218.     const WORD FOF_MULTIDESTFILES       = 0x0001;
  219.     const WORD FOF_CONFIRMMOUSE         = 0x0002;
  220.     const WORD FOF_SILENT               = 0x0004; // don't create progress/report
  221.     const WORD FOF_RENAMEONCOLLISION    = 0x0008;
  222.     const WORD FOF_NOCONFIRMATION       = 0x0010; // Don't prompt the user.
  223.     const WORD FOF_WANTMAPPINGHANDLE    = 0x0020; // Fill in SHFILEOPSTRUCT.hNameMappings
  224.                                                   // Must be freed using SHFreeNameMappings
  225.     const WORD FOF_ALLOWUNDO            = 0x0040;
  226.     const WORD FOF_FILESONLY            = 0x0080; // on *.*, do only files
  227.     const WORD FOF_SIMPLEPROGRESS       = 0x0100; // means don't show names of files
  228.     const WORD FOF_NOCONFIRMMKDIR       = 0x0200; // don't confirm making any needed dirs
  229.  
  230.     //typedef WORD FILEOP_FLAGS;
  231.  
  232.     const WORD PO_DELETE     = 0x0013;  // printer is being deleted
  233.     const WORD PO_RENAME     = 0x0014;  // printer is being renamed
  234.     const WORD PO_PORTCHANGE = 0x0020;  // port this printer connected to is being changed
  235.                                         // if this id is set, the strings received by
  236.                                         // the copyhook are a doubly-null terminated
  237.                                         // list of strings.  The first is the printer
  238.                                         // name and the second is the printer port.
  239.     const WORD PO_REN_PORT   = 0x0034;  // PO_RENAME and PO_PORTCHANGE at same time.
  240.  
  241.     // no POF_ flags currently defined
  242.  
  243.     // typedef WORD PRINTEROP_FLAGS;
  244.     */
  245.  
  246.     // implicit parameters are:
  247.     //      if pFrom or pTo are unqualified names the current directories are
  248.     //      taken from the global current drive/directory settings managed
  249.     //      by Get/SetCurrentDrive/Directory
  250.     //
  251.     //      the global confirmation settings
  252.  
  253.     /*
  254.     typedef struct _SHFILEOPSTRUCTA
  255.     {
  256.             HWND            hwnd;
  257.             UINT            wFunc;
  258.             LPCSTR          pFrom;
  259.             LPCSTR          pTo;
  260.             FILEOP_FLAGS    fFlags;
  261.             BOOL            fAnyOperationsAborted;
  262.             LPVOID          hNameMappings;
  263.             LPCSTR           lpszProgressTitle; // only used if FOF_SIMPLEPROGRESS
  264.     } SHFILEOPSTRUCTA, FAR *LPSHFILEOPSTRUCTA;
  265.     typedef SHFILEOPSTRUCTA SHFILEOPSTRUCT;
  266.     typedef LPSHFILEOPSTRUCTA LPSHFILEOPSTRUCT;
  267.     */
  268.  
  269.     // int WINAPI SHFileOperationA(LPSHFILEOPSTRUCTA lpFileOp);
  270.  
  271.     // void WINAPI SHFreeNameMappings(HANDLE hNameMappings);
  272.  
  273.     /*
  274.     typedef struct _SHNAMEMAPPINGA
  275.     {
  276.         LPSTR   pszOldPath;
  277.         LPSTR   pszNewPath;
  278.         int   cchOldPath;
  279.         int   cchNewPath;
  280.     } SHNAMEMAPPINGA, FAR *LPSHNAMEMAPPINGA;
  281.     typedef SHNAMEMAPPINGA SHNAMEMAPPING;
  282.     typedef LPSHNAMEMAPPINGA LPSHNAMEMAPPING;
  283.     */
  284.  
  285.     ////        #define SHGetNameMappingCount(_hnm)
  286.     //      DSA_GetItemCount(_hnm)
  287.     ////        #define SHGetNameMappingPtr(_hnm, _iItem) \
  288.     //      (LPSHNAMEMAPPING)DSA_GetItemPtr(_hnm, _iItem)
  289.  
  290.     //// End Shell File Operations
  291.  
  292.     #endif // WIN32
  293.  
  294.     //  Begin ShellExecuteEx and family
  295.  
  296.     // ShellExecute() and ShellExecuteEx() error codes
  297.  
  298.     // Regular WinExec() codes
  299.     const int SE_ERR_FNF                = 2;       // file not found
  300.     const int SE_ERR_PNF                = 3;       // path not found
  301.     const int SE_ERR_ACCESSDENIED       = 5;       // access denied
  302.     const int SE_ERR_OOM                = 8;       // out of memory
  303.     const int SE_ERR_DLLNOTFOUND       = 32;
  304.  
  305.  
  306.     // Error values for ShellExecute() beyond the regular WinExec() codes
  307.     const int SE_ERR_SHARE                  = 26;
  308.     const int SE_ERR_ASSOCINCOMPLETE        = 27;
  309.     const int SE_ERR_DDETIMEOUT             = 28;
  310.     const int SE_ERR_DDEFAIL                = 29;
  311.     const int SE_ERR_DDEBUSY                = 30;
  312.     const int SE_ERR_NOASSOC                = 31;
  313.  
  314.     // Note CLASSKEY overrides CLASSNAME
  315.     const DWORD SEE_MASK_CLASSNAME        = 0x00000001;
  316.     const DWORD SEE_MASK_CLASSKEY         = 0x00000003;
  317.     // Note INVOKEIDLIST overrides IDLIST
  318.     const DWORD SEE_MASK_IDLIST           = 0x00000004;
  319.     const DWORD SEE_MASK_INVOKEIDLIST     = 0x0000000c;
  320.     const DWORD SEE_MASK_ICON             = 0x00000010;
  321.     const DWORD SEE_MASK_HOTKEY           = 0x00000020;
  322.     const DWORD SEE_MASK_NOCLOSEPROCESS   = 0x00000040;
  323.     const DWORD SEE_MASK_CONNECTNETDRV    = 0x00000080;
  324.     const DWORD SEE_MASK_FLAG_DDEWAIT     = 0x00000100;
  325.     const DWORD SEE_MASK_DOENVSUBST       = 0x00000200;
  326.     const DWORD SEE_MASK_FLAG_NO_UI       = 0x00000400;
  327.     const DWORD SEE_MASK_UNICODE          = 0x00010000;
  328.  
  329.     /*
  330.     typedef struct _SHELLEXECUTEINFOA
  331.     {
  332.             DWORD cbSize;
  333.             ULONG fMask;
  334.             HWND hwnd;
  335.             LPCSTR   lpVerb;
  336.             LPCSTR   lpFile;
  337.             LPCSTR   lpParameters;
  338.             LPCSTR   lpDirectory;
  339.             int nShow;
  340.             HINSTANCE hInstApp;
  341.             // Optional fields
  342.             LPVOID lpIDList;
  343.             LPCSTR   lpClass;
  344.             HKEY hkeyClass;
  345.             DWORD dwHotKey;
  346.             HANDLE hIcon;
  347.             HANDLE hProcess;
  348.     } SHELLEXECUTEINFOA, FAR *LPSHELLEXECUTEINFOA;
  349.     typedef SHELLEXECUTEINFOA SHELLEXECUTEINFO;
  350.     typedef LPSHELLEXECUTEINFOA LPSHELLEXECUTEINFO;
  351.     */
  352.  
  353.     // BOOL WINAPI ShellExecuteExA(LPSHELLEXECUTEINFOA lpExecInfo);
  354.  
  355.     // void WINAPI WinExecErrorA(HWND hwnd, int error, LPCSTR lpstrFileName, LPCSTR lpstrTitle);
  356.  
  357.     //  End ShellExecuteEx and family
  358.  
  359.     #ifdef WIN32
  360.     // Tray notification definitions
  361.  
  362.     /*
  363.     typedef struct _NOTIFYICONDATAA {
  364.             DWORD cbSize;
  365.             HWND hWnd;
  366.             UINT uID;
  367.             UINT uFlags;
  368.             UINT uCallbackMessage;
  369.             HICON hIcon;
  370.             CHAR   szTip[64];
  371.     } NOTIFYICONDATAA, *PNOTIFYICONDATAA;
  372.     typedef NOTIFYICONDATAA NOTIFYICONDATA;
  373.     typedef PNOTIFYICONDATAA PNOTIFYICONDATA;
  374.     */
  375.  
  376.     const DWORD NIM_ADD       = 0x00000000;
  377.     const DWORD NIM_MODIFY    = 0x00000001;
  378.     const DWORD NIM_DELETE    = 0x00000002;
  379.  
  380.     const DWORD NIF_MESSAGE   = 0x00000001;
  381.     const DWORD NIF_ICON      = 0x00000002;
  382.     const DWORD NIF_TIP       = 0x00000004;
  383.  
  384.     // BOOL WINAPI Shell_NotifyIconA(DWORD dwMessage, PNOTIFYICONDATAA lpData);
  385.  
  386.     // End Tray Notification Icons
  387.  
  388.     // Begin SHGetFileInfo
  389.  
  390.     /*
  391.      * The SHGetFileInfo API provides an easy way to get attributes
  392.      * for a file given a pathname.
  393.      *
  394.      *   PARAMETERS
  395.      *
  396.      *     pszPath              file name to get info about
  397.      *     dwFileAttributes     file attribs, only used with SHGFI_USEFILEATTRIBUTES
  398.      *     psfi                 place to return file info
  399.      *     cbFileInfo           size of structure
  400.      *     uFlags               flags
  401.      *
  402.      *   RETURN
  403.      *     TRUE if things worked
  404.      */
  405.  
  406.     /*
  407.     typedef struct _SHFILEINFOA
  408.     {
  409.             HICON       hIcon;                      // out: icon
  410.             int         iIcon;                      // out: icon index
  411.             DWORD       dwAttributes;               // out: SFGAO_ flags
  412.             CHAR        szDisplayName[MAX_PATH];    // out: display name (or path)
  413.             CHAR        szTypeName[80];             // out: type name
  414.     } SHFILEINFOA;
  415.     typedef SHFILEINFOA SHFILEINFO;
  416.     */
  417.  
  418.     [
  419.     usesgetlasterror,
  420.     entry("SHGetMalloc"),
  421.     helpstring("Returns a pointer to an IMalloc used to allocate LPITEMID"),
  422.     ]
  423.     HRESULT WINAPI SHGetMalloc([in, out] IMalloc ** ppMalloc);
  424.     //HRESULT WINAPI SHGetMalloc([out] IUnknown * * MyMalloc);
  425.  
  426.     [ helpstring("SHGetFileInfo: Get icon") ]
  427.     const long SHGFI_ICON               = 0x00000100;
  428.     [ helpstring("SHGetFileInfo: Get display name") ]
  429.     const long SHGFI_DISPLAYNAME        = 0x00000200;
  430.     [ helpstring("SHGetFileInfo: Get type name") ]
  431.     const long SHGFI_TYPENAME           = 0x00000400;
  432.     [ helpstring("SHGetFileInfo: Get attributes") ]
  433.     const long SHGFI_ATTRIBUTES         = 0x00000800;
  434.     [ helpstring("SHGetFileInfo: Get icon location") ]
  435.     const long SHGFI_ICONLOCATION       = 0x00001000;
  436.     [ helpstring("SHGetFileInfo: Get EXE type") ]
  437.     const long SHGFI_EXETYPE            = 0x00002000;
  438.     [ helpstring("SHGetFileInfo: Get system icon index") ]
  439.     const long SHGFI_SYSICONINDEX       = 0x00004000;
  440.     [ helpstring("SHGetFileInfo: Put link overlay on icon") ]
  441.     const long SHGFI_LINKOVERLAY        = 0x00008000;
  442.     [ helpstring("SHGetFileInfo: Show icon in selected state") ]
  443.     const long SHGFI_SELECTED           = 0x00010000;
  444.     [ helpstring("SHGetFileInfo: Get large icon") ]
  445.     const long SHGFI_LARGEICON          = 0x00000000;
  446.     [ helpstring("SHGetFileInfo: Get small icon") ]
  447.     const long SHGFI_SMALLICON          = 0x00000001;
  448.     [ helpstring("SHGetFileInfo: Get open icon") ]
  449.     const long SHGFI_OPENICON           = 0x00000002;
  450.     [ helpstring("SHGetFileInfo: Get shell size icon") ]
  451.     const long SHGFI_SHELLICONSIZE      = 0x00000004;
  452.     [ helpstring("SHGetFileInfo: pszPath is a PIDL") ]
  453.     const long SHGFI_PIDL               = 0x00000008;
  454.     [ helpstring("SHGetFileInfo: Use passed file attributes") ]
  455.     const long SHGFI_USEFILEATTRIBUTES  = 0x00000010;
  456.  
  457.     /*
  458.     DWORD WINAPI SHGetFileInfoA(LPCSTR pszPath,
  459.                                 DWORD dwFileAttributes,
  460.                                 SHFILEINFOA FAR *psfi,
  461.                                 UINT cbFileInfo, UINT uFlags);
  462.  
  463.     BOOL WINAPI SHGetNewLinkInfoA(LPCSTR pszLinkTo, LPCSTR pszDir,
  464.                                   LPSTR pszName, BOOL FAR * pfMustCopy,
  465.                                   UINT uFlags);
  466.     */
  467.  
  468.     //define SHGNLI_PIDL           0x000000001     // pszLinkTo is a pidl
  469.     //define SHGNLI_PREFIXNAME     0x000000002     // Make name "Shortcut to xxx"
  470.  
  471.     [
  472.     usesgetlasterror,
  473.     entry("SHGetSpecialFolderLocation"),
  474.     helpstring("Get item ID of special folder location"),
  475.     ]
  476.     HRESULT WINAPI SHGetSpecialFolderLocation([in] HWND hwndOwner,
  477.                                               [in] int nFolder,
  478.                                               /* LPITEMIDLIST * ppidl */
  479.                                               [out] long * ppidl);
  480.  
  481.     [ helpstring("SHGetSpecialFolderLocation: Desktop") ]
  482.     const short CSIDL_DESKTOP         = 0x0000;
  483.     [ helpstring("SHGetSpecialFolderLocation: Programs") ]
  484.     const short CSIDL_PROGRAMS        = 0x0002;
  485.     [ helpstring("SHGetSpecialFolderLocation: Control Panel") ]
  486.     const short CSIDL_CONTROLS        = 0x0003;
  487.     [ helpstring("SHGetSpecialFolderLocation: Printers") ]
  488.     const short CSIDL_PRINTERS        = 0x0004;
  489.     const short CSIDL_PERSONAL        = 0x0005;
  490.     const short CSIDL_FAVORITES       = 0x0006;
  491.     [ helpstring("SHGetSpecialFolderLocation: Startup Directory") ]
  492.     const short CSIDL_STARTUP         = 0x0007;
  493.     [ helpstring("SHGetSpecialFolderLocation: Most Recently Used Documents") ]
  494.     const short CSIDL_RECENT          = 0x0008;
  495.     [ helpstring("SHGetSpecialFolderLocation: Send To Menu Items") ]
  496.     const short CSIDL_SENDTO          = 0x0009;
  497.     [ helpstring("SHGetSpecialFolderLocation: Recycle Bin") ]
  498.     const short CSIDL_BITBUCKET       = 0x000a;
  499.     [ helpstring("SHGetSpecialFolderLocation: Start Menu Directory") ]
  500.     const short CSIDL_STARTMENU       = 0x000b;
  501.     [ helpstring("SHGetSpecialFolderLocation: Desktop Directory") ]
  502.     const short CSIDL_DESKTOPDIRECTORY  = 0x0010;
  503.     [ helpstring("SHGetSpecialFolderLocation: My Computer") ]
  504.     const short CSIDL_DRIVES          = 0x0011;
  505.     [ helpstring("SHGetSpecialFolderLocation: Network Neighborhood") ]
  506.     const short CSIDL_NETWORK         = 0x0012;
  507.     [ helpstring("SHGetSpecialFolderLocation: Network Neighborhood Directory") ]
  508.     const short CSIDL_NETHOOD         = 0x0013;
  509.     [ helpstring("SHGetSpecialFolderLocation: Fonts") ]
  510.     const short CSIDL_FONTS           = 0x0014;
  511.     [ helpstring("SHGetSpecialFolderLocation: Templates") ]
  512.     const short CSIDL_TEMPLATES       = 0x0015;
  513.     #endif // WIN32
  514.  
  515. }
  516.